home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d20 / doorskl3.arc / DOORMISC.C < prev    next >
C/C++ Source or Header  |  1992-01-15  |  11KB  |  459 lines
  1. /**********************************************/
  2. /*                                              */
  3. /* XBBS Door Skeleton -- TC 2.0/MSC 6.0a code */
  4. /* Copyright (c) 1990/91 by M. Kimes          */
  5. /* All Rights Reserved                        */
  6. /* May be freely used for >>>FREE<<< programs */
  7. /* as long as you don't try to save any souls */
  8. /* (nasty habit)                              */
  9. /*                                            */
  10. /**********************************************/
  11.  
  12. /* Always include this module (with appropriate #defines) */
  13. /* Miscellaneous junk this module */
  14.  
  15. /**************************************************************************
  16.   Miscellaneous notes:
  17.  
  18.     #define XBBS and the program will be compiled to read ONLINE.XBS
  19.     #define DORINFO and the program will be compiled to read DORINFO?.DEF
  20.     #define both and first ONLINE.XBS will be read, then DORINFO?.DEF
  21.     (don't know why you'd wanna do that)
  22.     #define neither and all info must come from command line
  23.     #define FINDUSER and a routine to find a given user (by name) will
  24.             be compiled in (finduser()) for XBBS' USERS.BBS
  25.     #define NOREADFILE and the file reader routine (readtext()) will NOT
  26.             be compiled
  27.     #define DISABLEBREAK to disable CTRL-BREAK/CTRL-C
  28.     #define DIALTRANS to include code for sending modem control strings
  29.  
  30.     set chars to be unsigned by default
  31.     recommend large model (recompile screen2.asm and ansi.asm if other)
  32.     this code requires a FOSSIL for serial i/o--see function fossil()
  33. ***************************************************************************/
  34.  
  35. #include "doorskel.h"   /* XBBS include file */
  36.  
  37.  
  38.  
  39.  
  40.  
  41.  
  42. char * _fastcall addtolog (char *text) { /* write entries to logfile */
  43.  
  44.     FILE *pf;
  45.     char p[127];
  46.  
  47.  
  48.     pf = fopen(logfile,"a");
  49.     if (pf == NULL) return text;
  50.     fseek(pf,0,SEEK_END);
  51.     if (text[0] != '*') {
  52.         strcpy(p,fidodate());
  53.         p[16] = 0;
  54.         strcat(p,"  ");
  55.         strncat(p,text,126 - strlen(p));
  56.         p[126] = 0;
  57.     }
  58.     else {
  59.         strncpy(p,text,79);
  60.         p[79] = 0;
  61.     }
  62.     fputs(p,pf);
  63.     fputs("\n",pf);
  64.     fclose(pf);
  65.     return text;
  66. }
  67.  
  68.  
  69.  
  70. /* Position cursor */
  71.  
  72. void _fastcall cursor (int x, int y) {
  73.  
  74. #ifndef __TURBOC__
  75.     union REGS rg;
  76. #endif
  77.  
  78.  
  79.     x--;
  80.     y--;
  81. #ifndef __TURBOC__
  82.     rg.x.ax = 0x0200;
  83.     rg.x.bx = 0;
  84.     rg.x.dx = ((y << 8) & 0xff00) + x;
  85.     int86(0x10,&rg,&rg);
  86. #else
  87.     _AX = 0x0200;
  88.     _BX = 0;
  89.     _DX = ((y << 8) & 0xff00) + x;
  90.     geninterrupt(0x10);
  91. #endif
  92. }
  93.  
  94. /* Return cursor position */
  95.  
  96. void _fastcall curr_cursor (int *x,int *y) {
  97.  
  98. #ifndef __TURBOC__
  99.     union REGS rg;
  100.  
  101.  
  102.     rg.x.ax = 0x0300;
  103.     rg.x.bx = 0;
  104.     int86(0x10,&rg,&rg);
  105.     *x = rg.h.dl + 1;
  106.     *y = rg.h.dh + 1;
  107. #else
  108.     _AX = 0x0300;
  109.     _BX = 0;
  110.     geninterrupt(0x10);
  111.     *x = _DL + 1;
  112.     *y = _DH + 1;
  113. #endif
  114. }
  115.  
  116. /* insensitive strstr() */
  117.  
  118. char * _fastcall stristr (char *t, char *s) {
  119.  
  120.    char *t1;
  121.    char *s1;
  122.  
  123.  
  124.    while(*t) {
  125.       t1=t;
  126.       s1=s;
  127.       while(*s1) {
  128.          if (toupper(*s1)!=toupper(*t)) break;
  129.          else {
  130.             s1++;
  131.             t++;
  132.          }
  133.       }
  134.       if (!*s1) return t1;
  135.       t=t1+1;
  136.    }
  137.    return NULL;
  138. }
  139.  
  140.  
  141.  
  142. char * _fastcall stripcr (char *a) {  /* Strips trailing CR's & LF's */
  143.  
  144.   while (a[strlen(a)-1]=='\n' || a[strlen(a)-1]=='\r') a[strlen(a)-1]=0;
  145.   return a;
  146. }
  147.  
  148.  
  149.  
  150.  
  151. char * _fastcall lstrip (char *a) {    /* Strips leading blanks */
  152.  
  153.     while (*a == ' ') memmove (a,(a + 1),strlen(a));
  154.     return (a);
  155. }
  156.  
  157.  
  158.  
  159. char * _fastcall rstrip (char *a) {    /* Strips trailing blanks */
  160.  
  161.     while (*a && a[strlen(a) - 1] == ' ') a[strlen(a) - 1] = 0;
  162.     return a;
  163. }
  164.  
  165.  
  166.  
  167.  
  168. char _fastcall spawnit (char *strr) {
  169.  
  170.     /* Use this function to spawn external programs (like file transfer
  171.        protocols, archivers, etc.)  Just pass the string as you would
  172.        to system() except remember that it doesn't go through the
  173.        command processor (i.e. spawnit(getenv("COMSPEC")); not just
  174.        spawnit(""); ).  It'll clear the screen, run the program, then
  175.        return you to the appropriate drive and directory and redraw
  176.        the screen.  For a function that will swap to EMS or disk, I
  177.        direct you to the XBBS or HeadEdit source, or shop around for
  178.        one of those fancy packages they have now for XMS/EMS/disk
  179.        swapping and plug it in. */
  180.  
  181.    char *e[26];
  182.    static char a[256];
  183.    register word x;
  184.    int level = 0;
  185.    union REGS r;
  186.    char middle[MAXDIR+2];
  187.    word drive;
  188. #ifndef __TURBOC__
  189.    word temp;
  190. #endif
  191.    char dir[MAXDIR];
  192.  
  193.  
  194.    if(!strr || !*strr) return (char)(level = 1);
  195.  
  196.    set_cooked();
  197. #ifndef __TURBOC__
  198.    _dos_getdrive(&drive);
  199.    getcwd(dir,MAXDIR);
  200. #else
  201.    drive=getdisk();
  202.    getcurdir(++drive,dir);
  203. #endif
  204.    fossil(DEINIT,0);
  205.    fputs("\n\x1b[2J",stdout);
  206.    if(strr == getenv("COMSPEC")) {
  207.        fputs("EXIT to return to Door\n",stdout);
  208.    }
  209.    strcpy(a,strr);
  210.    for (x=0;x<26;x++) e[x]=NULL;
  211.    e[0]=strtok(a," ");
  212.    for (x = 1;(e[x] = strtok(0," "));x++) if (x == 25) break;
  213.    level = (int)spawnvp(P_WAIT,a,e);
  214.    fossil(INIT,0);
  215. #ifndef __TURBOC__
  216.    _dos_setdrive (drive,&temp);
  217. #else
  218.    setdisk (--drive);
  219. #endif
  220.    strcpy(middle,"\\");
  221.    strcat(middle,dir);
  222.    chdir(middle);
  223.  
  224.    if (!level) {
  225.        r.h.ah=77;
  226.        int86(33,&r,&r);
  227.        level=(int)r.h.al;
  228.    }
  229.  
  230.    set_raw();
  231.  
  232.    fputs("\x1b[2J\x1b[0m",stdout);
  233.    print_stat();
  234.  
  235.    return (char)level;
  236. }
  237.  
  238.  
  239. void _fastcall set_screen_size (void) {
  240.  
  241.     union REGS r;
  242.  
  243.  
  244.     r.h.ah = 0x0f;      /* set maxx and maxy globals to screen size */
  245.     int86(0x10,&r,&r);  /* this is called for you in DOORSKEL.C's main () */
  246.     if (maxx == 0)
  247.       maxx = (int) r.h.ah;
  248.     if (maxy == 0) {
  249.         r.x.ax = 0x1130;
  250.         r.x.dx = maxy;
  251.         int86(0x10,&r,&r);
  252.         maxy = (r.x.dx == 0) ? 25 : (r.x.dx + 1);   /* kludge, kludge, kludge */
  253.     }
  254. }
  255.  
  256.  
  257.  
  258. void _fastcall set_cooked (void) {
  259.  
  260.     union REGS rg;
  261.  
  262.  
  263.     rg.x.ax = 0x4400;         /* Set console in (std) cooked mode */
  264.     rg.x.bx = 1;
  265.     int86(33,&rg,&rg);
  266.     rg.h.dh = 0;
  267.     rg.h.dl = rg.h.dl & (char)(~0x20);
  268.     rg.x.ax = 0x4401;
  269.     int86(33,&rg,&rg);
  270. }
  271.  
  272.  
  273.  
  274. void _fastcall set_raw (void) {
  275.  
  276.     union REGS r;
  277.  
  278.  
  279.     r.h.ah = 0x33;
  280.     r.h.al = 0x01;
  281.     r.h.dl = 0x00;
  282.     int86(0x21,&r,&r);    /* turn ctrl-break flag off */
  283.  
  284.     r.x.ax = 0x4400;
  285.     r.x.bx = 1;
  286.     int86(0x21,&r,&r);
  287.     r.h.dh = 0;
  288.     r.h.dl = r.h.dl | 0x20;
  289.     r.x.ax = 0x4401;
  290.     int86(0x21,&r,&r);    /* set console in raw mode */
  291. }
  292.  
  293.  
  294. #ifndef __TURBOC__
  295.  
  296. char *searchpath (char *filename) {
  297.  
  298.     static char fbuf[153];
  299.     struct stat st;
  300.     char        *envbuf = NULL,*p,temp;
  301.  
  302.  
  303.     p = getenv("PATH");
  304.     if(!p) return filename;
  305.     envbuf = strdup(p);
  306.     if(!envbuf) return filename;
  307.  
  308.     p = strtok(envbuf,";");
  309.     do {
  310.         strncpy(fbuf,p,128);
  311.         fbuf[128] = 0;
  312.         temp = fbuf[strlen(fbuf) - 1];
  313.         if(temp != '/' && temp != '\\') strcat(fbuf,"\\");
  314.         strcat(fbuf,filename);
  315.         if(!stat(fbuf,&st)) {
  316.             if(envbuf) free(envbuf);
  317.             return fbuf;
  318.         }
  319.         p = strtok(0,";");
  320.     } while(p);
  321.     if(envbuf) free(envbuf);
  322.     return NULL;
  323. }
  324.  
  325. #endif
  326.  
  327.  
  328. /* Return video mode (B/W or color) */
  329.  
  330. int _fastcall vmode () {
  331.  
  332.     union REGS rg;
  333.  
  334.  
  335.     rg.h.ah = 15;
  336.     int86(16,&rg,&rg);
  337.     return rg.h.al;
  338. }
  339.  
  340.  
  341. #ifdef DIALTRANS
  342.  
  343.  int _fastcall dial_trans (char *s) {
  344.  
  345.     /* send chars to the modem with translation for ^v~| */
  346.     /* this won't be needed in a "normal" Door.  see also
  347.     /* macros SendByte and CSendByte. Note no carrier check
  348.     /* (obviously). */
  349.  
  350.     char *p = s;
  351.  
  352.  
  353.     while(p && *p) {
  354.         switch(*p) {
  355.             case '~':
  356.                     /* ~ = 1 second delay */
  357.                 my_sleep(1);
  358.                 break;
  359.             case '`':
  360.                 {
  361.                         /* ` = .1 second delay */
  362.                     clock_t t;
  363.  
  364.                     t = timerset(100L);
  365.                     while(!timeup(t)) {
  366.                         pause_mtask();
  367.                     }
  368.                 }
  369.                 break;
  370.             case '^':
  371.                     /* ^ = dtr up */
  372.                 fossil(DTR,UP);
  373.                 break;
  374.             case 'v':
  375.                     /* v = dtr down */
  376.                 fossil(DTR,DOWN);
  377.                 break;
  378.             case '|':
  379.                     /* | = carriage return */
  380.                 while(!fossil(TRANSMIT,'\r'));
  381.                 break;
  382.             default:
  383.                     /* else send it */
  384.                 while(!fossil(TRANSMIT,*p));
  385.         }
  386.         p++;
  387.     }
  388.     return 0;
  389.  }
  390.  
  391.  
  392. int _fastcall recvbyte (void) {     /* note:  normally you'd use inkey()
  393.                                        to get a keypress.  this is for
  394.                                        special purposes not usually
  395.                                        encountered in a door.  note
  396.                                        there's no carrier check in this
  397.                                        one. */
  398.  
  399.     union REGS rg;
  400.  
  401.  
  402.     rg.x.dx = commport;
  403.     rg.h.ah = GETSTAT;
  404.     int86(20,&rg,&rg);
  405.     if (!(rg.h.ah & 1)) return -1;      /* no char available */
  406.     return (int)fossil(RECVWAIT,0);
  407. }
  408.  
  409.  
  410. int _fastcall is_carrier (void) {   /* note: carrier check is already
  411.                                        implemented in the normal door
  412.                                        routines.  this is for special
  413.                                        purposes not usually encountered
  414.                                        in a door */
  415.  
  416.     union REGS rg;
  417.  
  418.  
  419.     rg.x.dx = commport;
  420.     rg.h.ah = GETSTAT;
  421.     int86(20,&rg,&rg);
  422.     if (!(rg.h.al & 128)) return 0;     /* no carrier */
  423.     return -1;
  424. }
  425.  
  426.  
  427. char * _fastcall get_modemstring (clock_t timer) {
  428.                                             /* gets a cr-terminated string
  429.                                                from the modem (usually a
  430.                                                result string) within timer
  431.                                                milliseconds */
  432.     clock_t      t1;
  433.     static char  str[81];
  434.     register int y = 0;
  435.     int          c;
  436.  
  437.  
  438.     *str = 0;                           /* initialize string */
  439.     t1 = timerset(timer);               /* initialize timer */
  440.  
  441.     while(!timeup(t1)) {
  442.         c = recvbyte();
  443.         switch(c) {
  444.             case -1;                    /* got nothing */
  445.                 pause_mtask();
  446.                 break;
  447.             case '\r':
  448.                 return str;             /* got it all */
  449.             default:
  450.                 str[y++] = (char)c;
  451.                 str[y] = 0;
  452.                 if(y > 79) return str;  /* max length */
  453.         }
  454.     }
  455.  
  456.     return str;     /* timeout if we get here */
  457. }
  458. #endif
  459.